home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / compiler / transformer.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  41.1 KB  |  1,461 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from compiler.ast import *
  5. import parser
  6. import symbol
  7. import token
  8. import sys
  9.  
  10. class WalkerError(StandardError):
  11.     pass
  12.  
  13. from compiler.consts import CO_VARARGS, CO_VARKEYWORDS
  14. from compiler.consts import OP_ASSIGN, OP_DELETE, OP_APPLY
  15.  
  16. def parseFile(path):
  17.     f = open(path, 'U')
  18.     src = f.read() + '\n'
  19.     f.close()
  20.     return parse(src)
  21.  
  22.  
  23. def parse(buf, mode = 'exec'):
  24.     if mode == 'exec' or mode == 'single':
  25.         return Transformer().parsesuite(buf)
  26.     elif mode == 'eval':
  27.         return Transformer().parseexpr(buf)
  28.     else:
  29.         raise ValueError("compile() arg 3 must be 'exec' or 'eval' or 'single'")
  30.  
  31.  
  32. def asList(nodes):
  33.     l = []
  34.     for item in nodes:
  35.         if hasattr(item, 'asList'):
  36.             l.append(item.asList())
  37.             continue
  38.         if type(item) is type((None, None)):
  39.             l.append(tuple(asList(item)))
  40.             continue
  41.         if type(item) is type([]):
  42.             l.append(asList(item))
  43.             continue
  44.         l.append(item)
  45.     
  46.     return l
  47.  
  48.  
  49. def extractLineNo(ast):
  50.     if not isinstance(ast[1], tuple):
  51.         return ast[2]
  52.     
  53.     for child in ast[1:]:
  54.         if isinstance(child, tuple):
  55.             lineno = extractLineNo(child)
  56.             if lineno is not None:
  57.                 return lineno
  58.             
  59.         lineno is not None
  60.     
  61.  
  62.  
  63. def Node(*args):
  64.     kind = args[0]
  65.     if nodes.has_key(kind):
  66.         
  67.         try:
  68.             return nodes[kind](*args[1:])
  69.         except TypeError:
  70.             print nodes[kind], len(args), args
  71.             raise 
  72.         except:
  73.             None<EXCEPTION MATCH>TypeError
  74.         
  75.  
  76.     None<EXCEPTION MATCH>TypeError
  77.     raise WalkerError, "Can't find appropriate Node type: %s" % str(args)
  78.  
  79.  
  80. class Transformer:
  81.     
  82.     def __init__(self):
  83.         self._dispatch = { }
  84.         for value, name in symbol.sym_name.items():
  85.             if hasattr(self, name):
  86.                 self._dispatch[value] = getattr(self, name)
  87.                 continue
  88.         
  89.         self._dispatch[token.NEWLINE] = self.com_NEWLINE
  90.         self._atom_dispatch = {
  91.             token.LPAR: self.atom_lpar,
  92.             token.LSQB: self.atom_lsqb,
  93.             token.LBRACE: self.atom_lbrace,
  94.             token.BACKQUOTE: self.atom_backquote,
  95.             token.NUMBER: self.atom_number,
  96.             token.STRING: self.atom_string,
  97.             token.NAME: self.atom_name }
  98.         self.encoding = None
  99.  
  100.     
  101.     def transform(self, tree):
  102.         if not isinstance(tree, tuple) or isinstance(tree, list):
  103.             tree = parser.ast2tuple(tree, line_info = 1)
  104.         
  105.         return self.compile_node(tree)
  106.  
  107.     
  108.     def parsesuite(self, text):
  109.         return self.transform(parser.suite(text))
  110.  
  111.     
  112.     def parseexpr(self, text):
  113.         return self.transform(parser.expr(text))
  114.  
  115.     
  116.     def parsefile(self, file):
  117.         if type(file) == type(''):
  118.             file = open(file)
  119.         
  120.         return self.parsesuite(file.read())
  121.  
  122.     
  123.     def compile_node(self, node):
  124.         n = node[0]
  125.         if n == symbol.encoding_decl:
  126.             self.encoding = node[2]
  127.             node = node[1]
  128.             n = node[0]
  129.         
  130.         if n == symbol.single_input:
  131.             return self.single_input(node[1:])
  132.         
  133.         if n == symbol.file_input:
  134.             return self.file_input(node[1:])
  135.         
  136.         if n == symbol.eval_input:
  137.             return self.eval_input(node[1:])
  138.         
  139.         if n == symbol.lambdef:
  140.             return self.lambdef(node[1:])
  141.         
  142.         if n == symbol.funcdef:
  143.             return self.funcdef(node[1:])
  144.         
  145.         if n == symbol.classdef:
  146.             return self.classdef(node[1:])
  147.         
  148.         raise WalkerError, ('unexpected node type', n)
  149.  
  150.     
  151.     def single_input(self, node):
  152.         n = node[0][0]
  153.         if n != token.NEWLINE:
  154.             return self.com_stmt(node[0])
  155.         
  156.         return Pass()
  157.  
  158.     
  159.     def file_input(self, nodelist):
  160.         doc = self.get_docstring(nodelist, symbol.file_input)
  161.         if doc is not None:
  162.             i = 1
  163.         else:
  164.             i = 0
  165.         stmts = []
  166.         for node in nodelist[i:]:
  167.             if node[0] != token.ENDMARKER and node[0] != token.NEWLINE:
  168.                 self.com_append_stmt(stmts, node)
  169.                 continue
  170.         
  171.         return Module(doc, Stmt(stmts))
  172.  
  173.     
  174.     def eval_input(self, nodelist):
  175.         return Expression(self.com_node(nodelist[0]))
  176.  
  177.     
  178.     def decorator_name(self, nodelist):
  179.         listlen = len(nodelist)
  180.         item = self.atom_name(nodelist)
  181.         i = 1
  182.         while i < listlen:
  183.             item = Getattr(item, nodelist[i + 1][1])
  184.             i += 2
  185.         return item
  186.  
  187.     
  188.     def decorator(self, nodelist):
  189.         funcname = self.decorator_name(nodelist[1][1:])
  190.         if len(nodelist) > 3:
  191.             expr = self.com_call_function(funcname, nodelist[3])
  192.         else:
  193.             expr = funcname
  194.         return expr
  195.  
  196.     
  197.     def decorators(self, nodelist):
  198.         items = []
  199.         for dec_nodelist in nodelist:
  200.             items.append(self.decorator(dec_nodelist[1:]))
  201.         
  202.         return Decorators(items)
  203.  
  204.     
  205.     def funcdef(self, nodelist):
  206.         if len(nodelist) == 6:
  207.             decorators = self.decorators(nodelist[0][1:])
  208.         else:
  209.             decorators = None
  210.         lineno = nodelist[-4][2]
  211.         name = nodelist[-4][1]
  212.         args = nodelist[-3][2]
  213.         if args[0] == symbol.varargslist:
  214.             (names, defaults, flags) = self.com_arglist(args[1:])
  215.         else:
  216.             names = defaults = ()
  217.             flags = 0
  218.         doc = self.get_docstring(nodelist[-1])
  219.         code = self.com_node(nodelist[-1])
  220.         if doc is not None:
  221.             del code.nodes[0]
  222.         
  223.         return Function(decorators, name, names, defaults, flags, doc, code, lineno = lineno)
  224.  
  225.     
  226.     def lambdef(self, nodelist):
  227.         if nodelist[2][0] == symbol.varargslist:
  228.             (names, defaults, flags) = self.com_arglist(nodelist[2][1:])
  229.         else:
  230.             names = defaults = ()
  231.             flags = 0
  232.         code = self.com_node(nodelist[-1])
  233.         return Lambda(names, defaults, flags, code, lineno = nodelist[1][2])
  234.  
  235.     old_lambdef = lambdef
  236.     
  237.     def classdef(self, nodelist):
  238.         name = nodelist[1][1]
  239.         doc = self.get_docstring(nodelist[-1])
  240.         if nodelist[2][0] == token.COLON:
  241.             bases = []
  242.         elif nodelist[3][0] == token.RPAR:
  243.             bases = []
  244.         else:
  245.             bases = self.com_bases(nodelist[3])
  246.         code = self.com_node(nodelist[-1])
  247.         if doc is not None:
  248.             del code.nodes[0]
  249.         
  250.         return Class(name, bases, doc, code, lineno = nodelist[1][2])
  251.  
  252.     
  253.     def stmt(self, nodelist):
  254.         return self.com_stmt(nodelist[0])
  255.  
  256.     small_stmt = stmt
  257.     flow_stmt = stmt
  258.     compound_stmt = stmt
  259.     
  260.     def simple_stmt(self, nodelist):
  261.         stmts = []
  262.         for i in range(0, len(nodelist), 2):
  263.             self.com_append_stmt(stmts, nodelist[i])
  264.         
  265.         return Stmt(stmts)
  266.  
  267.     
  268.     def parameters(self, nodelist):
  269.         raise WalkerError
  270.  
  271.     
  272.     def varargslist(self, nodelist):
  273.         raise WalkerError
  274.  
  275.     
  276.     def fpdef(self, nodelist):
  277.         raise WalkerError
  278.  
  279.     
  280.     def fplist(self, nodelist):
  281.         raise WalkerError
  282.  
  283.     
  284.     def dotted_name(self, nodelist):
  285.         raise WalkerError
  286.  
  287.     
  288.     def comp_op(self, nodelist):
  289.         raise WalkerError
  290.  
  291.     
  292.     def trailer(self, nodelist):
  293.         raise WalkerError
  294.  
  295.     
  296.     def sliceop(self, nodelist):
  297.         raise WalkerError
  298.  
  299.     
  300.     def argument(self, nodelist):
  301.         raise WalkerError
  302.  
  303.     
  304.     def expr_stmt(self, nodelist):
  305.         en = nodelist[-1]
  306.         exprNode = self.lookup_node(en)(en[1:])
  307.         if len(nodelist) == 1:
  308.             return Discard(exprNode, lineno = exprNode.lineno)
  309.         
  310.         if nodelist[1][0] == token.EQUAL:
  311.             nodesl = []
  312.             for i in range(0, len(nodelist) - 2, 2):
  313.                 nodesl.append(self.com_assign(nodelist[i], OP_ASSIGN))
  314.             
  315.             return Assign(nodesl, exprNode, lineno = nodelist[1][2])
  316.         else:
  317.             lval = self.com_augassign(nodelist[0])
  318.             op = self.com_augassign_op(nodelist[1])
  319.             return AugAssign(lval, op[1], exprNode, lineno = op[2])
  320.         raise WalkerError, "can't get here"
  321.  
  322.     
  323.     def print_stmt(self, nodelist):
  324.         items = []
  325.         if len(nodelist) == 1:
  326.             start = 1
  327.             dest = None
  328.         elif nodelist[1][0] == token.RIGHTSHIFT:
  329.             dest = self.com_node(nodelist[2])
  330.             start = 4
  331.         else:
  332.             dest = None
  333.             start = 1
  334.         for i in range(start, len(nodelist), 2):
  335.             items.append(self.com_node(nodelist[i]))
  336.         
  337.         if nodelist[-1][0] == token.COMMA:
  338.             return Print(items, dest, lineno = nodelist[0][2])
  339.         
  340.         return Printnl(items, dest, lineno = nodelist[0][2])
  341.  
  342.     
  343.     def del_stmt(self, nodelist):
  344.         return self.com_assign(nodelist[1], OP_DELETE)
  345.  
  346.     
  347.     def pass_stmt(self, nodelist):
  348.         return Pass(lineno = nodelist[0][2])
  349.  
  350.     
  351.     def break_stmt(self, nodelist):
  352.         return Break(lineno = nodelist[0][2])
  353.  
  354.     
  355.     def continue_stmt(self, nodelist):
  356.         return Continue(lineno = nodelist[0][2])
  357.  
  358.     
  359.     def return_stmt(self, nodelist):
  360.         if len(nodelist) < 2:
  361.             return Return(Const(None), lineno = nodelist[0][2])
  362.         
  363.         return Return(self.com_node(nodelist[1]), lineno = nodelist[0][2])
  364.  
  365.     
  366.     def yield_stmt(self, nodelist):
  367.         expr = self.com_node(nodelist[0])
  368.         return Discard(expr, lineno = expr.lineno)
  369.  
  370.     
  371.     def yield_expr(self, nodelist):
  372.         if len(nodelist) > 1:
  373.             value = self.com_node(nodelist[1])
  374.         else:
  375.             value = Const(None)
  376.         return Yield(value, lineno = nodelist[0][2])
  377.  
  378.     
  379.     def raise_stmt(self, nodelist):
  380.         if len(nodelist) > 5:
  381.             expr3 = self.com_node(nodelist[5])
  382.         else:
  383.             expr3 = None
  384.         if len(nodelist) > 3:
  385.             expr2 = self.com_node(nodelist[3])
  386.         else:
  387.             expr2 = None
  388.         if len(nodelist) > 1:
  389.             expr1 = self.com_node(nodelist[1])
  390.         else:
  391.             expr1 = None
  392.         return Raise(expr1, expr2, expr3, lineno = nodelist[0][2])
  393.  
  394.     
  395.     def import_stmt(self, nodelist):
  396.         return self.com_node(nodelist[0])
  397.  
  398.     
  399.     def import_name(self, nodelist):
  400.         return Import(self.com_dotted_as_names(nodelist[1]), lineno = nodelist[0][2])
  401.  
  402.     
  403.     def import_from(self, nodelist):
  404.         idx = 1
  405.         while nodelist[idx][1] == '.':
  406.             idx += 1
  407.         level = idx - 1
  408.         if nodelist[idx][0] == symbol.dotted_name:
  409.             fromname = self.com_dotted_name(nodelist[idx])
  410.             idx += 1
  411.         else:
  412.             fromname = ''
  413.         if nodelist[idx + 1][0] == token.STAR:
  414.             return From(fromname, [
  415.                 ('*', None)], level, lineno = nodelist[0][2])
  416.         else:
  417.             node = nodelist[idx + 1 + (nodelist[idx + 1][0] == token.LPAR)]
  418.             return From(fromname, self.com_import_as_names(node), level, lineno = nodelist[0][2])
  419.  
  420.     
  421.     def global_stmt(self, nodelist):
  422.         names = []
  423.         for i in range(1, len(nodelist), 2):
  424.             names.append(nodelist[i][1])
  425.         
  426.         return Global(names, lineno = nodelist[0][2])
  427.  
  428.     
  429.     def exec_stmt(self, nodelist):
  430.         expr1 = self.com_node(nodelist[1])
  431.         if len(nodelist) >= 4:
  432.             expr2 = self.com_node(nodelist[3])
  433.             if len(nodelist) >= 6:
  434.                 expr3 = self.com_node(nodelist[5])
  435.             else:
  436.                 expr3 = None
  437.         else:
  438.             expr2 = None
  439.             expr3 = None
  440.         return Exec(expr1, expr2, expr3, lineno = nodelist[0][2])
  441.  
  442.     
  443.     def assert_stmt(self, nodelist):
  444.         expr1 = self.com_node(nodelist[1])
  445.         if len(nodelist) == 4:
  446.             expr2 = self.com_node(nodelist[3])
  447.         else:
  448.             expr2 = None
  449.         return Assert(expr1, expr2, lineno = nodelist[0][2])
  450.  
  451.     
  452.     def if_stmt(self, nodelist):
  453.         tests = []
  454.         for i in range(0, len(nodelist) - 3, 4):
  455.             testNode = self.com_node(nodelist[i + 1])
  456.             suiteNode = self.com_node(nodelist[i + 3])
  457.             tests.append((testNode, suiteNode))
  458.         
  459.         if len(nodelist) % 4 == 3:
  460.             elseNode = self.com_node(nodelist[-1])
  461.         else:
  462.             elseNode = None
  463.         return If(tests, elseNode, lineno = nodelist[0][2])
  464.  
  465.     
  466.     def while_stmt(self, nodelist):
  467.         testNode = self.com_node(nodelist[1])
  468.         bodyNode = self.com_node(nodelist[3])
  469.         if len(nodelist) > 4:
  470.             elseNode = self.com_node(nodelist[6])
  471.         else:
  472.             elseNode = None
  473.         return While(testNode, bodyNode, elseNode, lineno = nodelist[0][2])
  474.  
  475.     
  476.     def for_stmt(self, nodelist):
  477.         assignNode = self.com_assign(nodelist[1], OP_ASSIGN)
  478.         listNode = self.com_node(nodelist[3])
  479.         bodyNode = self.com_node(nodelist[5])
  480.         if len(nodelist) > 8:
  481.             elseNode = self.com_node(nodelist[8])
  482.         else:
  483.             elseNode = None
  484.         return For(assignNode, listNode, bodyNode, elseNode, lineno = nodelist[0][2])
  485.  
  486.     
  487.     def try_stmt(self, nodelist):
  488.         return self.com_try_except_finally(nodelist)
  489.  
  490.     
  491.     def with_stmt(self, nodelist):
  492.         return self.com_with(nodelist)
  493.  
  494.     
  495.     def with_var(self, nodelist):
  496.         return self.com_with_var(nodelist)
  497.  
  498.     
  499.     def suite(self, nodelist):
  500.         if len(nodelist) == 1:
  501.             return self.com_stmt(nodelist[0])
  502.         
  503.         stmts = []
  504.         for node in nodelist:
  505.             if node[0] == symbol.stmt:
  506.                 self.com_append_stmt(stmts, node)
  507.                 continue
  508.         
  509.         return Stmt(stmts)
  510.  
  511.     
  512.     def testlist(self, nodelist):
  513.         return self.com_binary(Tuple, nodelist)
  514.  
  515.     testlist_safe = testlist
  516.     testlist1 = testlist
  517.     exprlist = testlist
  518.     
  519.     def testlist_gexp(self, nodelist):
  520.         if len(nodelist) == 2 and nodelist[1][0] == symbol.gen_for:
  521.             test = self.com_node(nodelist[0])
  522.             return self.com_generator_expression(test, nodelist[1])
  523.         
  524.         return self.testlist(nodelist)
  525.  
  526.     
  527.     def test(self, nodelist):
  528.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  529.             return self.lambdef(nodelist[0])
  530.         
  531.         then = self.com_node(nodelist[0])
  532.         if len(nodelist) > 1:
  533.             test = self.com_node(nodelist[2])
  534.             else_ = self.com_node(nodelist[4])
  535.             return IfExp(test, then, else_, lineno = nodelist[1][2])
  536.         
  537.         return then
  538.  
  539.     
  540.     def or_test(self, nodelist):
  541.         if len(nodelist) == 1 and nodelist[0][0] == symbol.lambdef:
  542.             return self.lambdef(nodelist[0])
  543.         
  544.         return self.com_binary(Or, nodelist)
  545.  
  546.     old_test = or_test
  547.     
  548.     def and_test(self, nodelist):
  549.         return self.com_binary(And, nodelist)
  550.  
  551.     
  552.     def not_test(self, nodelist):
  553.         result = self.com_node(nodelist[-1])
  554.         if len(nodelist) == 2:
  555.             return Not(result, lineno = nodelist[0][2])
  556.         
  557.         return result
  558.  
  559.     
  560.     def comparison(self, nodelist):
  561.         node = self.com_node(nodelist[0])
  562.         if len(nodelist) == 1:
  563.             return node
  564.         
  565.         results = []
  566.         for i in range(2, len(nodelist), 2):
  567.             nl = nodelist[i - 1]
  568.             n = nl[1]
  569.             if n[0] == token.NAME:
  570.                 type = n[1]
  571.                 if len(nl) == 3:
  572.                     if type == 'not':
  573.                         type = 'not in'
  574.                     else:
  575.                         type = 'is not'
  576.                 
  577.             else:
  578.                 type = _cmp_types[n[0]]
  579.             lineno = nl[1][2]
  580.             results.append((type, self.com_node(nodelist[i])))
  581.         
  582.         return Compare(node, results, lineno = lineno)
  583.  
  584.     
  585.     def expr(self, nodelist):
  586.         return self.com_binary(Bitor, nodelist)
  587.  
  588.     
  589.     def xor_expr(self, nodelist):
  590.         return self.com_binary(Bitxor, nodelist)
  591.  
  592.     
  593.     def and_expr(self, nodelist):
  594.         return self.com_binary(Bitand, nodelist)
  595.  
  596.     
  597.     def shift_expr(self, nodelist):
  598.         node = self.com_node(nodelist[0])
  599.         for i in range(2, len(nodelist), 2):
  600.             right = self.com_node(nodelist[i])
  601.             if nodelist[i - 1][0] == token.LEFTSHIFT:
  602.                 node = LeftShift([
  603.                     node,
  604.                     right], lineno = nodelist[1][2])
  605.                 continue
  606.             if nodelist[i - 1][0] == token.RIGHTSHIFT:
  607.                 node = RightShift([
  608.                     node,
  609.                     right], lineno = nodelist[1][2])
  610.                 continue
  611.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  612.         
  613.         return node
  614.  
  615.     
  616.     def arith_expr(self, nodelist):
  617.         node = self.com_node(nodelist[0])
  618.         for i in range(2, len(nodelist), 2):
  619.             right = self.com_node(nodelist[i])
  620.             if nodelist[i - 1][0] == token.PLUS:
  621.                 node = Add([
  622.                     node,
  623.                     right], lineno = nodelist[1][2])
  624.                 continue
  625.             if nodelist[i - 1][0] == token.MINUS:
  626.                 node = Sub([
  627.                     node,
  628.                     right], lineno = nodelist[1][2])
  629.                 continue
  630.             raise ValueError, 'unexpected token: %s' % nodelist[i - 1][0]
  631.         
  632.         return node
  633.  
  634.     
  635.     def term(self, nodelist):
  636.         node = self.com_node(nodelist[0])
  637.         for i in range(2, len(nodelist), 2):
  638.             right = self.com_node(nodelist[i])
  639.             t = nodelist[i - 1][0]
  640.             if t == token.STAR:
  641.                 node = Mul([
  642.                     node,
  643.                     right])
  644.             elif t == token.SLASH:
  645.                 node = Div([
  646.                     node,
  647.                     right])
  648.             elif t == token.PERCENT:
  649.                 node = Mod([
  650.                     node,
  651.                     right])
  652.             elif t == token.DOUBLESLASH:
  653.                 node = FloorDiv([
  654.                     node,
  655.                     right])
  656.             else:
  657.                 raise ValueError, 'unexpected token: %s' % t
  658.             node.lineno = nodelist[1][2]
  659.         
  660.         return node
  661.  
  662.     
  663.     def factor(self, nodelist):
  664.         elt = nodelist[0]
  665.         t = elt[0]
  666.         node = self.lookup_node(nodelist[-1])(nodelist[-1][1:])
  667.         if t == token.PLUS:
  668.             return UnaryAdd(node, lineno = elt[2])
  669.         elif t == token.MINUS:
  670.             return UnarySub(node, lineno = elt[2])
  671.         elif t == token.TILDE:
  672.             node = Invert(node, lineno = elt[2])
  673.         
  674.         return node
  675.  
  676.     
  677.     def power(self, nodelist):
  678.         node = self.com_node(nodelist[0])
  679.         for i in range(1, len(nodelist)):
  680.             elt = nodelist[i]
  681.             if elt[0] == token.DOUBLESTAR:
  682.                 return Power([
  683.                     node,
  684.                     self.com_node(nodelist[i + 1])], lineno = elt[2])
  685.             
  686.             node = self.com_apply_trailer(node, elt)
  687.         
  688.         return node
  689.  
  690.     
  691.     def atom(self, nodelist):
  692.         return self._atom_dispatch[nodelist[0][0]](nodelist)
  693.  
  694.     
  695.     def atom_lpar(self, nodelist):
  696.         if nodelist[1][0] == token.RPAR:
  697.             return Tuple((), lineno = nodelist[0][2])
  698.         
  699.         return self.com_node(nodelist[1])
  700.  
  701.     
  702.     def atom_lsqb(self, nodelist):
  703.         if nodelist[1][0] == token.RSQB:
  704.             return List((), lineno = nodelist[0][2])
  705.         
  706.         return self.com_list_constructor(nodelist[1])
  707.  
  708.     
  709.     def atom_lbrace(self, nodelist):
  710.         if nodelist[1][0] == token.RBRACE:
  711.             return Dict((), lineno = nodelist[0][2])
  712.         
  713.         return self.com_dictmaker(nodelist[1])
  714.  
  715.     
  716.     def atom_backquote(self, nodelist):
  717.         return Backquote(self.com_node(nodelist[1]))
  718.  
  719.     
  720.     def atom_number(self, nodelist):
  721.         k = eval(nodelist[0][1])
  722.         return Const(k, lineno = nodelist[0][2])
  723.  
  724.     
  725.     def decode_literal(self, lit):
  726.         if self.encoding:
  727.             if self.encoding not in ('utf-8', 'iso-8859-1'):
  728.                 lit = unicode(lit, 'utf-8').encode(self.encoding)
  729.             
  730.             return eval('# coding: %s\n%s' % (self.encoding, lit))
  731.         else:
  732.             return eval(lit)
  733.  
  734.     
  735.     def atom_string(self, nodelist):
  736.         k = ''
  737.         for node in nodelist:
  738.             k += self.decode_literal(node[1])
  739.         
  740.         return Const(k, lineno = nodelist[0][2])
  741.  
  742.     
  743.     def atom_name(self, nodelist):
  744.         return Name(nodelist[0][1], lineno = nodelist[0][2])
  745.  
  746.     
  747.     def lookup_node(self, node):
  748.         return self._dispatch[node[0]]
  749.  
  750.     
  751.     def com_node(self, node):
  752.         return self._dispatch[node[0]](node[1:])
  753.  
  754.     
  755.     def com_NEWLINE(self, *args):
  756.         return Discard(Const(None))
  757.  
  758.     
  759.     def com_arglist(self, nodelist):
  760.         names = []
  761.         defaults = []
  762.         flags = 0
  763.         i = 0
  764.         while i < len(nodelist):
  765.             node = nodelist[i]
  766.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  767.                 if node[0] == token.STAR:
  768.                     node = nodelist[i + 1]
  769.                     if node[0] == token.NAME:
  770.                         names.append(node[1])
  771.                         flags = flags | CO_VARARGS
  772.                         i = i + 3
  773.                     
  774.                 
  775.                 if i < len(nodelist):
  776.                     t = nodelist[i][0]
  777.                     if t == token.DOUBLESTAR:
  778.                         node = nodelist[i + 1]
  779.                     else:
  780.                         raise ValueError, 'unexpected token: %s' % t
  781.                     names.append(node[1])
  782.                     flags = flags | CO_VARKEYWORDS
  783.                 
  784.                 break
  785.             
  786.             names.append(self.com_fpdef(node))
  787.             i = i + 1
  788.             if i < len(nodelist) and nodelist[i][0] == token.EQUAL:
  789.                 defaults.append(self.com_node(nodelist[i + 1]))
  790.                 i = i + 2
  791.             elif len(defaults):
  792.                 raise SyntaxError, 'non-default argument follows default argument'
  793.             
  794.             i = i + 1
  795.         return (names, defaults, flags)
  796.  
  797.     
  798.     def com_fpdef(self, node):
  799.         if node[1][0] == token.LPAR:
  800.             return self.com_fplist(node[2])
  801.         
  802.         return node[1][1]
  803.  
  804.     
  805.     def com_fplist(self, node):
  806.         if len(node) == 2:
  807.             return self.com_fpdef(node[1])
  808.         
  809.         list = []
  810.         for i in range(1, len(node), 2):
  811.             list.append(self.com_fpdef(node[i]))
  812.         
  813.         return tuple(list)
  814.  
  815.     
  816.     def com_dotted_name(self, node):
  817.         name = ''
  818.         for n in node:
  819.             if type(n) == type(()) and n[0] == 1:
  820.                 name = name + n[1] + '.'
  821.                 continue
  822.         
  823.         return name[:-1]
  824.  
  825.     
  826.     def com_dotted_as_name(self, node):
  827.         node = node[1:]
  828.         dot = self.com_dotted_name(node[0][1:])
  829.         if len(node) == 1:
  830.             return (dot, None)
  831.         
  832.         return (dot, node[2][1])
  833.  
  834.     
  835.     def com_dotted_as_names(self, node):
  836.         node = node[1:]
  837.         names = [
  838.             self.com_dotted_as_name(node[0])]
  839.         for i in range(2, len(node), 2):
  840.             names.append(self.com_dotted_as_name(node[i]))
  841.         
  842.         return names
  843.  
  844.     
  845.     def com_import_as_name(self, node):
  846.         node = node[1:]
  847.         if len(node) == 1:
  848.             return (node[0][1], None)
  849.         
  850.         return (node[0][1], node[2][1])
  851.  
  852.     
  853.     def com_import_as_names(self, node):
  854.         node = node[1:]
  855.         names = [
  856.             self.com_import_as_name(node[0])]
  857.         for i in range(2, len(node), 2):
  858.             names.append(self.com_import_as_name(node[i]))
  859.         
  860.         return names
  861.  
  862.     
  863.     def com_bases(self, node):
  864.         bases = []
  865.         for i in range(1, len(node), 2):
  866.             bases.append(self.com_node(node[i]))
  867.         
  868.         return bases
  869.  
  870.     
  871.     def com_try_except_finally(self, nodelist):
  872.         if nodelist[3][0] == token.NAME:
  873.             return TryFinally(self.com_node(nodelist[2]), self.com_node(nodelist[5]), lineno = nodelist[0][2])
  874.         
  875.         clauses = []
  876.         elseNode = None
  877.         finallyNode = None
  878.         for i in range(3, len(nodelist), 3):
  879.             node = nodelist[i]
  880.             if node[0] == symbol.except_clause:
  881.                 if len(node) > 2:
  882.                     expr1 = self.com_node(node[2])
  883.                     if len(node) > 4:
  884.                         expr2 = self.com_assign(node[4], OP_ASSIGN)
  885.                     else:
  886.                         expr2 = None
  887.                 else:
  888.                     expr1 = None
  889.                     expr2 = None
  890.                 clauses.append((expr1, expr2, self.com_node(nodelist[i + 2])))
  891.             
  892.             if node[0] == token.NAME:
  893.                 if node[1] == 'else':
  894.                     elseNode = self.com_node(nodelist[i + 2])
  895.                 elif node[1] == 'finally':
  896.                     finallyNode = self.com_node(nodelist[i + 2])
  897.                 
  898.             node[1] == 'else'
  899.         
  900.         try_except = TryExcept(self.com_node(nodelist[2]), clauses, elseNode, lineno = nodelist[0][2])
  901.         if finallyNode:
  902.             return TryFinally(try_except, finallyNode, lineno = nodelist[0][2])
  903.         else:
  904.             return try_except
  905.  
  906.     
  907.     def com_with(self, nodelist):
  908.         expr = self.com_node(nodelist[1])
  909.         body = self.com_node(nodelist[-1])
  910.         if nodelist[2][0] == token.COLON:
  911.             var = None
  912.         else:
  913.             var = self.com_assign(nodelist[2][2], OP_ASSIGN)
  914.         return With(expr, var, body, lineno = nodelist[0][2])
  915.  
  916.     
  917.     def com_with_var(self, nodelist):
  918.         return self.com_node(nodelist[1])
  919.  
  920.     
  921.     def com_augassign_op(self, node):
  922.         return node[1]
  923.  
  924.     
  925.     def com_augassign(self, node):
  926.         l = self.com_node(node)
  927.         if l.__class__ in (Name, Slice, Subscript, Getattr):
  928.             return l
  929.         
  930.         raise SyntaxError, "can't assign to %s" % l.__class__.__name__
  931.  
  932.     
  933.     def com_assign(self, node, assigning):
  934.         while None:
  935.             t = node[0]
  936.             if t in (symbol.exprlist, symbol.testlist, symbol.testlist_safe, symbol.testlist_gexp):
  937.                 if len(node) > 2:
  938.                     return self.com_assign_tuple(node, assigning)
  939.                 
  940.                 node = node[1]
  941.                 continue
  942.             if t in _assign_types:
  943.                 if len(node) > 2:
  944.                     raise SyntaxError, "can't assign to operator"
  945.                 
  946.                 node = node[1]
  947.                 continue
  948.             if t == symbol.power:
  949.                 if node[1][0] != symbol.atom:
  950.                     raise SyntaxError, "can't assign to operator"
  951.                 
  952.                 if len(node) > 2:
  953.                     primary = self.com_node(node[1])
  954.                     for i in range(2, len(node) - 1):
  955.                         ch = node[i]
  956.                         if ch[0] == token.DOUBLESTAR:
  957.                             raise SyntaxError, "can't assign to operator"
  958.                         
  959.                         primary = self.com_apply_trailer(primary, ch)
  960.                     
  961.                     return self.com_assign_trailer(primary, node[-1], assigning)
  962.                 
  963.                 node = node[1]
  964.                 continue
  965.             if t == symbol.atom:
  966.                 t = node[1][0]
  967.                 if t == token.LPAR:
  968.                     node = node[2]
  969.                     if node[0] == token.RPAR:
  970.                         raise SyntaxError, "can't assign to ()"
  971.                     
  972.                 elif t == token.LSQB:
  973.                     node = node[2]
  974.                     if node[0] == token.RSQB:
  975.                         raise SyntaxError, "can't assign to []"
  976.                     
  977.                     return self.com_assign_list(node, assigning)
  978.                 elif t == token.NAME:
  979.                     return self.com_assign_name(node[1], assigning)
  980.                 else:
  981.                     raise SyntaxError, "can't assign to literal"
  982.             t == token.LPAR
  983.             raise SyntaxError, 'bad assignment (%s)' % t
  984.             continue
  985.             return None
  986.  
  987.     
  988.     def com_assign_tuple(self, node, assigning):
  989.         assigns = []
  990.         for i in range(1, len(node), 2):
  991.             assigns.append(self.com_assign(node[i], assigning))
  992.         
  993.         return AssTuple(assigns, lineno = extractLineNo(node))
  994.  
  995.     
  996.     def com_assign_list(self, node, assigning):
  997.         assigns = []
  998.         for i in range(1, len(node), 2):
  999.             if i + 1 < len(node):
  1000.                 if node[i + 1][0] == symbol.list_for:
  1001.                     raise SyntaxError, "can't assign to list comprehension"
  1002.                 
  1003.             
  1004.             assigns.append(self.com_assign(node[i], assigning))
  1005.         
  1006.         return AssList(assigns, lineno = extractLineNo(node))
  1007.  
  1008.     
  1009.     def com_assign_name(self, node, assigning):
  1010.         return AssName(node[1], assigning, lineno = node[2])
  1011.  
  1012.     
  1013.     def com_assign_trailer(self, primary, node, assigning):
  1014.         t = node[1][0]
  1015.         if t == token.DOT:
  1016.             return self.com_assign_attr(primary, node[2], assigning)
  1017.         
  1018.         if t == token.LSQB:
  1019.             return self.com_subscriptlist(primary, node[2], assigning)
  1020.         
  1021.         if t == token.LPAR:
  1022.             raise SyntaxError, "can't assign to function call"
  1023.         
  1024.         raise SyntaxError, 'unknown trailer type: %s' % t
  1025.  
  1026.     
  1027.     def com_assign_attr(self, primary, node, assigning):
  1028.         return AssAttr(primary, node[1], assigning, lineno = node[-1])
  1029.  
  1030.     
  1031.     def com_binary(self, constructor, nodelist):
  1032.         l = len(nodelist)
  1033.         if l == 1:
  1034.             n = nodelist[0]
  1035.             return self.lookup_node(n)(n[1:])
  1036.         
  1037.         items = []
  1038.         for i in range(0, l, 2):
  1039.             n = nodelist[i]
  1040.             items.append(self.lookup_node(n)(n[1:]))
  1041.         
  1042.         return constructor(items, lineno = extractLineNo(nodelist))
  1043.  
  1044.     
  1045.     def com_stmt(self, node):
  1046.         result = self.lookup_node(node)(node[1:])
  1047.         if isinstance(result, Stmt):
  1048.             return result
  1049.         
  1050.         return Stmt([
  1051.             result])
  1052.  
  1053.     
  1054.     def com_append_stmt(self, stmts, node):
  1055.         result = self.lookup_node(node)(node[1:])
  1056.         if isinstance(result, Stmt):
  1057.             stmts.extend(result.nodes)
  1058.         else:
  1059.             stmts.append(result)
  1060.  
  1061.     if hasattr(symbol, 'list_for'):
  1062.         
  1063.         def com_list_constructor(self, nodelist):
  1064.             values = []
  1065.             for i in range(1, len(nodelist)):
  1066.                 if nodelist[i][0] == symbol.list_for:
  1067.                     return self.com_list_comprehension(values[0], nodelist[i])
  1068.                 elif nodelist[i][0] == token.COMMA:
  1069.                     continue
  1070.                 
  1071.                 values.append(self.com_node(nodelist[i]))
  1072.             
  1073.             return List(values, lineno = values[0].lineno)
  1074.  
  1075.         
  1076.         def com_list_comprehension(self, expr, node):
  1077.             lineno = node[1][2]
  1078.             fors = []
  1079.             while node:
  1080.                 t = node[1][1]
  1081.                 if t == 'for':
  1082.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1083.                     listNode = self.com_node(node[4])
  1084.                     newfor = ListCompFor(assignNode, listNode, [])
  1085.                     newfor.lineno = node[1][2]
  1086.                     fors.append(newfor)
  1087.                     if len(node) == 5:
  1088.                         node = None
  1089.                     else:
  1090.                         node = self.com_list_iter(node[5])
  1091.                 len(node) == 5
  1092.                 if t == 'if':
  1093.                     test = self.com_node(node[2])
  1094.                     newif = ListCompIf(test, lineno = node[1][2])
  1095.                     newfor.ifs.append(newif)
  1096.                     if len(node) == 3:
  1097.                         node = None
  1098.                     else:
  1099.                         node = self.com_list_iter(node[3])
  1100.                 len(node) == 3
  1101.                 raise SyntaxError, 'unexpected list comprehension element: %s %d' % (node, lineno)
  1102.             return ListComp(expr, fors, lineno = lineno)
  1103.  
  1104.         
  1105.         def com_list_iter(self, node):
  1106.             return node[1]
  1107.  
  1108.     else:
  1109.         
  1110.         def com_list_constructor(self, nodelist):
  1111.             values = []
  1112.             for i in range(1, len(nodelist), 2):
  1113.                 values.append(self.com_node(nodelist[i]))
  1114.             
  1115.             return List(values, lineno = values[0].lineno)
  1116.  
  1117.     if hasattr(symbol, 'gen_for'):
  1118.         
  1119.         def com_generator_expression(self, expr, node):
  1120.             lineno = node[1][2]
  1121.             fors = []
  1122.             while node:
  1123.                 t = node[1][1]
  1124.                 if t == 'for':
  1125.                     assignNode = self.com_assign(node[2], OP_ASSIGN)
  1126.                     genNode = self.com_node(node[4])
  1127.                     newfor = GenExprFor(assignNode, genNode, [], lineno = node[1][2])
  1128.                     fors.append(newfor)
  1129.                     if len(node) == 5:
  1130.                         node = None
  1131.                     else:
  1132.                         node = self.com_gen_iter(node[5])
  1133.                 len(node) == 5
  1134.                 if t == 'if':
  1135.                     test = self.com_node(node[2])
  1136.                     newif = GenExprIf(test, lineno = node[1][2])
  1137.                     newfor.ifs.append(newif)
  1138.                     if len(node) == 3:
  1139.                         node = None
  1140.                     else:
  1141.                         node = self.com_gen_iter(node[3])
  1142.                 len(node) == 3
  1143.                 raise SyntaxError, 'unexpected generator expression element: %s %d' % (node, lineno)
  1144.             fors[0].is_outmost = True
  1145.             return GenExpr(GenExprInner(expr, fors), lineno = lineno)
  1146.  
  1147.         
  1148.         def com_gen_iter(self, node):
  1149.             return node[1]
  1150.  
  1151.     
  1152.     
  1153.     def com_dictmaker(self, nodelist):
  1154.         items = []
  1155.         for i in range(1, len(nodelist), 4):
  1156.             items.append((self.com_node(nodelist[i]), self.com_node(nodelist[i + 2])))
  1157.         
  1158.         return Dict(items, lineno = items[0][0].lineno)
  1159.  
  1160.     
  1161.     def com_apply_trailer(self, primaryNode, nodelist):
  1162.         t = nodelist[1][0]
  1163.         if t == token.LPAR:
  1164.             return self.com_call_function(primaryNode, nodelist[2])
  1165.         
  1166.         if t == token.DOT:
  1167.             return self.com_select_member(primaryNode, nodelist[2])
  1168.         
  1169.         if t == token.LSQB:
  1170.             return self.com_subscriptlist(primaryNode, nodelist[2], OP_APPLY)
  1171.         
  1172.         raise SyntaxError, 'unknown node type: %s' % t
  1173.  
  1174.     
  1175.     def com_select_member(self, primaryNode, nodelist):
  1176.         if nodelist[0] != token.NAME:
  1177.             raise SyntaxError, 'member must be a name'
  1178.         
  1179.         return Getattr(primaryNode, nodelist[1], lineno = nodelist[2])
  1180.  
  1181.     
  1182.     def com_call_function(self, primaryNode, nodelist):
  1183.         if nodelist[0] == token.RPAR:
  1184.             return CallFunc(primaryNode, [], lineno = extractLineNo(nodelist))
  1185.         
  1186.         args = []
  1187.         kw = 0
  1188.         len_nodelist = len(nodelist)
  1189.         for i in range(1, len_nodelist, 2):
  1190.             node = nodelist[i]
  1191.             if node[0] == token.STAR or node[0] == token.DOUBLESTAR:
  1192.                 break
  1193.             
  1194.             (kw, result) = self.com_argument(node, kw)
  1195.             if len_nodelist != 2 and isinstance(result, GenExpr) and len(node) == 3 and node[2][0] == symbol.gen_for:
  1196.                 raise SyntaxError, 'generator expression needs parenthesis'
  1197.             
  1198.             args.append(result)
  1199.         else:
  1200.             i = i + 1
  1201.         if i < len_nodelist and nodelist[i][0] == token.COMMA:
  1202.             i = i + 1
  1203.         
  1204.         star_node = None
  1205.         dstar_node = None
  1206.         while i < len_nodelist:
  1207.             tok = nodelist[i]
  1208.             ch = nodelist[i + 1]
  1209.             i = i + 3
  1210.             if tok[0] == token.STAR:
  1211.                 if star_node is not None:
  1212.                     raise SyntaxError, 'already have the varargs indentifier'
  1213.                 
  1214.                 star_node = self.com_node(ch)
  1215.                 continue
  1216.             if tok[0] == token.DOUBLESTAR:
  1217.                 if dstar_node is not None:
  1218.                     raise SyntaxError, 'already have the kwargs indentifier'
  1219.                 
  1220.                 dstar_node = self.com_node(ch)
  1221.                 continue
  1222.             raise SyntaxError, 'unknown node type: %s' % tok
  1223.         return CallFunc(primaryNode, args, star_node, dstar_node, lineno = extractLineNo(nodelist))
  1224.  
  1225.     
  1226.     def com_argument(self, nodelist, kw):
  1227.         if len(nodelist) == 3 and nodelist[2][0] == symbol.gen_for:
  1228.             test = self.com_node(nodelist[1])
  1229.             return (0, self.com_generator_expression(test, nodelist[2]))
  1230.         
  1231.         if len(nodelist) == 2:
  1232.             if kw:
  1233.                 raise SyntaxError, 'non-keyword arg after keyword arg'
  1234.             
  1235.             return (0, self.com_node(nodelist[1]))
  1236.         
  1237.         result = self.com_node(nodelist[3])
  1238.         n = nodelist[1]
  1239.         while len(n) == 2 and n[0] != token.NAME:
  1240.             n = n[1]
  1241.         if n[0] != token.NAME:
  1242.             raise SyntaxError, "keyword can't be an expression (%s)" % n[0]
  1243.         
  1244.         node = Keyword(n[1], result, lineno = n[2])
  1245.         return (1, node)
  1246.  
  1247.     
  1248.     def com_subscriptlist(self, primary, nodelist, assigning):
  1249.         if len(nodelist) == 2:
  1250.             sub = nodelist[1]
  1251.             if (sub[1][0] == token.COLON or len(sub) > 2 or sub[2][0] == token.COLON) and sub[-1][0] != symbol.sliceop:
  1252.                 return self.com_slice(primary, sub, assigning)
  1253.             
  1254.         
  1255.         subscripts = []
  1256.         for i in range(1, len(nodelist), 2):
  1257.             subscripts.append(self.com_subscript(nodelist[i]))
  1258.         
  1259.         return Subscript(primary, assigning, subscripts, lineno = extractLineNo(nodelist))
  1260.  
  1261.     
  1262.     def com_subscript(self, node):
  1263.         ch = node[1]
  1264.         t = ch[0]
  1265.         if t == token.DOT and node[2][0] == token.DOT:
  1266.             return Ellipsis()
  1267.         
  1268.         if t == token.COLON or len(node) > 2:
  1269.             return self.com_sliceobj(node)
  1270.         
  1271.         return self.com_node(ch)
  1272.  
  1273.     
  1274.     def com_sliceobj(self, node):
  1275.         items = []
  1276.         if node[1][0] == token.COLON:
  1277.             items.append(Const(None))
  1278.             i = 2
  1279.         else:
  1280.             items.append(self.com_node(node[1]))
  1281.             i = 3
  1282.         if i < len(node) and node[i][0] == symbol.test:
  1283.             items.append(self.com_node(node[i]))
  1284.             i = i + 1
  1285.         else:
  1286.             items.append(Const(None))
  1287.         for j in range(i, len(node)):
  1288.             ch = node[j]
  1289.             if len(ch) == 2:
  1290.                 items.append(Const(None))
  1291.                 continue
  1292.             items.append(self.com_node(ch[2]))
  1293.         
  1294.         return Sliceobj(items, lineno = extractLineNo(node))
  1295.  
  1296.     
  1297.     def com_slice(self, primary, node, assigning):
  1298.         lower = None
  1299.         upper = None
  1300.         if len(node) == 3:
  1301.             if node[1][0] == token.COLON:
  1302.                 upper = self.com_node(node[2])
  1303.             else:
  1304.                 lower = self.com_node(node[1])
  1305.         elif len(node) == 4:
  1306.             lower = self.com_node(node[1])
  1307.             upper = self.com_node(node[3])
  1308.         
  1309.         return Slice(primary, assigning, lower, upper, lineno = extractLineNo(node))
  1310.  
  1311.     
  1312.     def get_docstring(self, node, n = None):
  1313.         if n is None:
  1314.             n = node[0]
  1315.             node = node[1:]
  1316.         
  1317.         if n == symbol.suite:
  1318.             if len(node) == 1:
  1319.                 return self.get_docstring(node[0])
  1320.             
  1321.             for sub in node:
  1322.                 if sub[0] == symbol.stmt:
  1323.                     return self.get_docstring(sub)
  1324.                     continue
  1325.             
  1326.             return None
  1327.         
  1328.         if n == symbol.file_input:
  1329.             for sub in node:
  1330.                 if sub[0] == symbol.stmt:
  1331.                     return self.get_docstring(sub)
  1332.                     continue
  1333.             
  1334.             return None
  1335.         
  1336.         if n == symbol.atom:
  1337.             if node[0][0] == token.STRING:
  1338.                 s = ''
  1339.                 for t in node:
  1340.                     s = s + eval(t[1])
  1341.                 
  1342.                 return s
  1343.             
  1344.             return None
  1345.         
  1346.         if n == symbol.stmt and n == symbol.simple_stmt or n == symbol.small_stmt:
  1347.             return self.get_docstring(node[0])
  1348.         
  1349.         if n in _doc_nodes and len(node) == 1:
  1350.             return self.get_docstring(node[0])
  1351.         
  1352.  
  1353.  
  1354. _doc_nodes = [
  1355.     symbol.expr_stmt,
  1356.     symbol.testlist,
  1357.     symbol.testlist_safe,
  1358.     symbol.test,
  1359.     symbol.or_test,
  1360.     symbol.and_test,
  1361.     symbol.not_test,
  1362.     symbol.comparison,
  1363.     symbol.expr,
  1364.     symbol.xor_expr,
  1365.     symbol.and_expr,
  1366.     symbol.shift_expr,
  1367.     symbol.arith_expr,
  1368.     symbol.term,
  1369.     symbol.factor,
  1370.     symbol.power]
  1371. _cmp_types = {
  1372.     token.LESS: '<',
  1373.     token.GREATER: '>',
  1374.     token.EQEQUAL: '==',
  1375.     token.EQUAL: '==',
  1376.     token.LESSEQUAL: '<=',
  1377.     token.GREATEREQUAL: '>=',
  1378.     token.NOTEQUAL: '!=' }
  1379. _legal_node_types = [
  1380.     symbol.funcdef,
  1381.     symbol.classdef,
  1382.     symbol.stmt,
  1383.     symbol.small_stmt,
  1384.     symbol.flow_stmt,
  1385.     symbol.simple_stmt,
  1386.     symbol.compound_stmt,
  1387.     symbol.expr_stmt,
  1388.     symbol.print_stmt,
  1389.     symbol.del_stmt,
  1390.     symbol.pass_stmt,
  1391.     symbol.break_stmt,
  1392.     symbol.continue_stmt,
  1393.     symbol.return_stmt,
  1394.     symbol.raise_stmt,
  1395.     symbol.import_stmt,
  1396.     symbol.global_stmt,
  1397.     symbol.exec_stmt,
  1398.     symbol.assert_stmt,
  1399.     symbol.if_stmt,
  1400.     symbol.while_stmt,
  1401.     symbol.for_stmt,
  1402.     symbol.try_stmt,
  1403.     symbol.with_stmt,
  1404.     symbol.suite,
  1405.     symbol.testlist,
  1406.     symbol.testlist_safe,
  1407.     symbol.test,
  1408.     symbol.and_test,
  1409.     symbol.not_test,
  1410.     symbol.comparison,
  1411.     symbol.exprlist,
  1412.     symbol.expr,
  1413.     symbol.xor_expr,
  1414.     symbol.and_expr,
  1415.     symbol.shift_expr,
  1416.     symbol.arith_expr,
  1417.     symbol.term,
  1418.     symbol.factor,
  1419.     symbol.power,
  1420.     symbol.atom]
  1421. if hasattr(symbol, 'yield_stmt'):
  1422.     _legal_node_types.append(symbol.yield_stmt)
  1423.  
  1424. if hasattr(symbol, 'yield_expr'):
  1425.     _legal_node_types.append(symbol.yield_expr)
  1426.  
  1427. _assign_types = [
  1428.     symbol.test,
  1429.     symbol.or_test,
  1430.     symbol.and_test,
  1431.     symbol.not_test,
  1432.     symbol.comparison,
  1433.     symbol.expr,
  1434.     symbol.xor_expr,
  1435.     symbol.and_expr,
  1436.     symbol.shift_expr,
  1437.     symbol.arith_expr,
  1438.     symbol.term,
  1439.     symbol.factor]
  1440. _names = { }
  1441. for k, v in symbol.sym_name.items():
  1442.     _names[k] = v
  1443.  
  1444. for k, v in token.tok_name.items():
  1445.     _names[k] = v
  1446.  
  1447.  
  1448. def debug_tree(tree):
  1449.     l = []
  1450.     for elt in tree:
  1451.         if isinstance(elt, int):
  1452.             l.append(_names.get(elt, elt))
  1453.             continue
  1454.         if isinstance(elt, str):
  1455.             l.append(elt)
  1456.             continue
  1457.         l.append(debug_tree(elt))
  1458.     
  1459.     return l
  1460.  
  1461.